import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import '../../../common/services/index.dart';
import '../../../common/models/index.dart';
import '../../../common/routers/index.dart';
import '../../../common/utils/index.dart';

/// 登录页面控制器
/// 负责登录页面的状态管理、表单验证和登录业务逻辑
class LoginController extends GetxController {
  // 1. 静态常量（类级别）
  static const String tag = 'LoginController';
  static const int maxRetryCount = 3;
  static const Duration animationDuration = Duration(milliseconds: 800);
  static const Duration loadingDelay = Duration(milliseconds: 1000);
  
  // 2. 实例常量
  final String pageTitle = '登录';
  final String welcomeText = '欢迎回来';
  final String subtitleText = '墨韵心境，静待花开';
  
  // 3. 响应式变量（Rx系列）
  // 基础类型 - 使用.obs写法（推荐95%场景）
  var isLoading = false.obs;                    // RxBool - 加载状态
  var isPasswordVisible = false.obs;           // RxBool - 密码可见性
  var isRememberPassword = false.obs;          // RxBool - 记住密码
  var hasError = false.obs;                    // RxBool - 错误状态
  var username = ''.obs;                       // RxString - 用户名
  var password = ''.obs;                       // RxString - 密码
  var errorMessage = ''.obs;                   // RxString - 错误信息
  var loginAttempts = 0.obs;                   // RxInt - 登录尝试次数
  var logoScale = 0.8.obs;                     // RxDouble - Logo缩放动画
  var formOpacity = 0.0.obs;                   // RxDouble - 表单透明度动画
  
  // 集合类型 - 使用.obs写法
  var validationErrors = <String, String>{}.obs; // RxMap - 表单验证错误
  
  // 可空类型 - 特殊场景使用
  var lastLoginTime = RxnString();             // 可空字符串 - 上次登录时间
  
  // 4. 普通变量（非响应式）
  bool _isInitialized = false;
  String _savedUsername = '';
  String _savedPassword = '';
  Timer? _animationTimer;
  Timer? _formTimer;
  int _retryCount = 0;
  
  // 5. 控制器和服务依赖
  final TextEditingController usernameController = TextEditingController();
  final TextEditingController passwordController = TextEditingController();
  final GlobalKey<FormState> formKey = GlobalKey<FormState>();
  final FocusNode usernameFocusNode = FocusNode();
  final FocusNode passwordFocusNode = FocusNode();
  
  // 服务依赖
  UserService get _userService => Get.find<UserService>();
  StorageService get _storageService => Get.find<StorageService>();
  
  // 6. 构造函数
  LoginController() {
    debugPrint('$tag: Constructor');
    
    // 确保动画变量的安全初始值
    logoScale.value = 0.8;
    formOpacity.value = 0.0;
  }

  // 7. 私有初始化方法
  void _initData() {
    debugPrint('$tag: 初始化登录页面数据');
    
    // 加载保存的登录信息
    _loadSavedCredentials();
    
    // 启动入场动画
    _startEntranceAnimation();
    
    _isInitialized = true;
    update(["login"]);
  }
  
  /// 加载保存的登录凭据
  void _loadSavedCredentials() {
    try {
      _savedUsername = _storageService.getString('saved_username') ?? '';
      _savedPassword = _storageService.getString('saved_password') ?? '';
      final rememberPassword = _storageService.getBool('remember_password') ?? false;
      
      bool hasLoadedSavedCredentials = false;
      
      if (rememberPassword && _savedUsername.isNotEmpty) {
        username.value = _savedUsername;
        usernameController.text = _savedUsername;
        isRememberPassword.value = true;
        
        if (_savedPassword.isNotEmpty) {
          password.value = _savedPassword;
          passwordController.text = _savedPassword;
        }
        
        hasLoadedSavedCredentials = true;
        debugPrint('$tag: 已加载保存的登录信息');
      }
      
      // 如果没有保存的登录信息，设置默认测试账号和密码
      if (!hasLoadedSavedCredentials) {
        _setDefaultTestCredentials();
      }
      
      // 获取上次登录时间
      lastLoginTime.value = _storageService.getString('last_login_time');
      
    } catch (e) {
      debugPrint('$tag: 加载保存的登录信息失败: $e');
      // 异常时也设置默认测试账号
      _setDefaultTestCredentials();
    }
  }
  
  /// 设置默认测试账号和密码
  void _setDefaultTestCredentials() {
    const defaultUsername = 'admin';
    const defaultPassword = 'admin123';
    
    username.value = defaultUsername;
    password.value = defaultPassword;
    usernameController.text = defaultUsername;
    passwordController.text = defaultPassword;
    
    debugPrint('$tag: 🧪 已设置默认测试账号 - $defaultUsername');
  }
  
  /// 启动入场动画
  void _startEntranceAnimation() {
    // Logo缩放动画
    logoScale.value = 0.8;
    formOpacity.value = 0.0;
    
    _animationTimer = Timer.periodic(const Duration(milliseconds: 50), (timer) {
      if (logoScale.value < 1.0) {
        logoScale.value = (logoScale.value + 0.02).clamp(0.0, 1.0);
      } else {
        logoScale.value = 1.0; // 确保最终值为1.0
        timer.cancel();
        // Logo动画完成后开始表单动画
        _startFormAnimation();
      }
      update(["login"]);
    });
  }
  
  /// 启动表单显示动画
  void _startFormAnimation() {
    _formTimer = Timer.periodic(const Duration(milliseconds: 30), (timer) {
      if (formOpacity.value < 1.0) {
        formOpacity.value = (formOpacity.value + 0.05).clamp(0.0, 1.0);
        update(["login"]);
      } else {
        formOpacity.value = 1.0; // 确保最终值为1.0
        timer.cancel();
        _formTimer = null;
      }
    });
  }

  // 8. 业务方法
  
  /// 用户名输入变化处理
  void onUsernameChanged(String value) {
    username.value = value;
    _clearFieldError('username');
    update(["login"]);
  }
  
  /// 密码输入变化处理
  void onPasswordChanged(String value) {
    password.value = value;
    _clearFieldError('password');
    update(["login"]);
  }
  
  /// 切换密码可见性
  void togglePasswordVisibility() {
    isPasswordVisible.value = !isPasswordVisible.value;
    update(["login"]);
  }
  
  /// 切换记住密码状态
  void toggleRememberPassword() {
    isRememberPassword.value = !isRememberPassword.value;
    update(["login"]);
  }
  
  /// 登录按钮点击处理
  void onLoginTap() async {
    if (!_isInitialized) {
      debugPrint('$tag: 控制器未初始化，忽略登录操作');
      return;
    }
    
    debugPrint('$tag: 开始登录流程');
    
    // 清除焦点
    usernameFocusNode.unfocus();
    passwordFocusNode.unfocus();
    
    // 表单验证
    if (!_validateForm()) {
      debugPrint('$tag: 表单验证失败');
      return;
    }
    
    await _performLogin();
  }
  
  /// 执行登录逻辑
  Future<void> _performLogin() async {
    try {
      isLoading.value = true;
      hasError.value = false;
      errorMessage.value = '';
      _retryCount = 0;
      update(["login"]);
      
      // 创建登录请求
      final loginRequest = LoginReq(
        username: username.value.trim(),
        password: password.value,
      );
      
      debugPrint('$tag: 调用用户服务登录API');
      
      // 调用用户服务登录
      final result = await _userService.login(
        username: loginRequest.username ?? '',
        password: loginRequest.password ?? '',
      );
      
      if (result.isSuccess) {
        debugPrint('$tag: 登录成功');
        
        // 保存登录凭据（如果用户选择记住密码）
        await _saveCredentialsIfNeeded();
        
        // 更新登录尝试次数
        loginAttempts.value++;
        
        // 登录成功后获取用户信息
        await _fetchUserInfo();
        
        // 显示成功提示
        LoadingUtil.success('登录成功，欢迎回来！');
        
        // 延迟跳转，让用户看到成功状态
        await Future.delayed(const Duration(milliseconds: 800));
        
        // 跳转到主页面 - 使用offAllNamed清除所有路由历史
        Get.offAllNamed(RouteNames.systemMain);
        
      } else {
        _handleLoginFailure(result.errorMessage ?? '登录失败，请重试');
      }
      
    } catch (e) {
      debugPrint('$tag: 登录异常: $e');
      _handleLoginFailure('网络连接异常，请检查网络后重试');
    } finally {
      isLoading.value = false;
      update(["login"]);
    }
  }
  
  /// 处理登录失败
  void _handleLoginFailure(String message) {
    hasError.value = true;
    errorMessage.value = message;
    
    // 增加重试次数
    _retryCount++;
    loginAttempts.value++;
    
    // 显示错误提示
    LoadingUtil.error(message, duration: const Duration(seconds: 3));
    
    // 如果尝试次数过多，清空密码
    if (_retryCount >= maxRetryCount) {
      password.value = '';
      passwordController.clear();
      debugPrint('$tag: 达到最大重试次数，清空密码');
    }
    
    update(["login"]);
  }
  
  /// 表单验证
  bool _validateForm() {
    validationErrors.clear();
    
    // 验证用户名
    if (username.value.trim().isEmpty) {
      validationErrors['username'] = '请输入用户名';
    } else if (username.value.trim().length < 2) {
      validationErrors['username'] = '用户名至少2个字符';
    }
    
    // 验证密码
    if (password.value.isEmpty) {
      validationErrors['password'] = '请输入密码';
    } else if (password.value.length < 6) {
      validationErrors['password'] = '密码至少6个字符';
    }
    
    final isValid = validationErrors.isEmpty;
    
    if (!isValid) {
      hasError.value = true;
      errorMessage.value = validationErrors.values.first;
    }
    
    update(["login"]);
    return isValid;
  }
  
  /// 清除字段错误
  void _clearFieldError(String fieldName) {
    if (validationErrors.containsKey(fieldName)) {
      validationErrors.remove(fieldName);
      if (validationErrors.isEmpty) {
        hasError.value = false;
        errorMessage.value = '';
      }
    }
  }
  
  /// 保存登录凭据（如果需要）
  Future<void> _saveCredentialsIfNeeded() async {
    try {
      if (isRememberPassword.value) {
        await _storageService.setString('saved_username', username.value);
        await _storageService.setString('saved_password', password.value);
        await _storageService.setBool('remember_password', true);
        debugPrint('$tag: 已保存登录凭据');
      } else {
        // 清除保存的凭据
        await _storageService.remove('saved_username');
        await _storageService.remove('saved_password');
        await _storageService.setBool('remember_password', false);
        debugPrint('$tag: 已清除保存的登录凭据');
      }
      
      // 保存登录时间
      await _storageService.setString('last_login_time', DateTime.now().toIso8601String());
      
    } catch (e) {
      debugPrint('$tag: 保存登录凭据失败: $e');
    }
  }
  
  /// 获取用户信息
  /// 
  /// 通过UserService获取用户信息，符合分层架构原则
  Future<void> _fetchUserInfo() async {
    try {
      debugPrint('$tag: 开始获取用户信息');
      
      // 调用UserService获取用户个人资料（会自动保存到本地）
      final userProfile = await _userService.getUserProfile();
      
      debugPrint('$tag: 用户信息获取成功');
      debugPrint('$tag: 用户昵称: ${userProfile.nickName}');
      debugPrint('$tag: 用户角色: ${userProfile.roles?.length ?? 0}个');
      debugPrint('$tag: 用户部门: ${userProfile.dept?.deptName ?? "无"}');
      
    } catch (e) {
      debugPrint('$tag: 获取用户信息异常: $e');
      
      // 异常不影响登录流程，但要记录日志
      LoadingUtil.info('用户信息获取异常，请稍后刷新');
    }
  }
  
  /// 忘记密码处理
  void onForgotPasswordTap() {
    debugPrint('$tag: 忘记密码点击');
    
    LoadingUtil.info('请联系管理员重置密码');
  }
  
  /// 重置登录状态
  void resetLoginState() {
    debugPrint('$tag: 重置登录状态');
    
    isLoading.value = false;
    hasError.value = false;
    errorMessage.value = '';
    validationErrors.clear();
    loginAttempts.value = 0;
    _retryCount = 0;
    
    update(["login"]);
  }

  // 9. 生命周期方法
  @override
  void onInit() {
    super.onInit();
    debugPrint('$tag: onInit');
    
    // 设置文本控制器监听
    usernameController.addListener(() => onUsernameChanged(usernameController.text));
    passwordController.addListener(() => onPasswordChanged(passwordController.text));
  }

  @override
  void onReady() {
    super.onReady();
    debugPrint('$tag: onReady');
    _initData();
  }

  @override
  void onClose() {
    debugPrint('$tag: onClose');
    
    // 清理Timer资源
    _animationTimer?.cancel();
    _formTimer?.cancel();
    
    // 清理文本控制器
    usernameController.dispose();
    passwordController.dispose();
    
    // 清理焦点节点
    usernameFocusNode.dispose();
    passwordFocusNode.dispose();
    
    super.onClose();
  }
}
